function myAbsencesWindow() {
	var ds_user_absence = new Ext.data.Store({
				proxy : new Ext.data.HttpProxy({
							url : 'absence_absencesOfUser_list.action'
						}),
				reader : new Ext.data.JsonReader({
							root : 'absences',
							totalProperty : 'totalCount'
						}, [{
									name : 'absencerId',
									mapping : 'userId',
									type : 'long'
								}, {
									name : 'userName',
									mapping : 'user.userName',
									type : 'string'
								}, {
									name : 'dateHalf',
									mapping : 'dateHalf',
									type : 'string'
								}, {
									name : 'type',
									mapping : 'type',
									type : 'short'
								}, {
									name : 'status',
									mapping : 'status',
									type : 'short'
								}, {
									name : 'confirmedStatus',
									mapping : 'confirmedStatus',
									type : 'short'
								}, {
									name : 'confirmerName',
									mapping : 'confirmerName',
									type : 'string'
								}, {
									name : 'confirmedTimestamp',
									mapping : 'confirmedTimestamp',
									type : 'long'
								}, {
									name : 'remark',
									mapping : 'remark',
									type : 'string'
								}, {
									name : 'createdTimestamp',
									mapping : 'createdTimestamp'
								}, {
									name : 'lastModifierName',
									mapping : 'lastModifierName',
									type : 'string'
								}, {
									name : 'lastModified',
									mapping : 'lastModified'
								}, {
									name : 'operation',
									type : 'string'
								}])
			});

	// 时间格式转换
	function formatTime(value, metadata, record) {
		if (null== value) {
			return null;
		} else {
			return new Date(value).format('Y-m-d');
		}
	}
	var sm_checkbox_selectAbsenceOfSomeone=new Ext.grid.CheckboxSelectionModel({
		checkOnly :true,
		listeners: {
			rowdeselect: function(sm_checkbox_selectAbsenceOfSomeone, rowIndex, record){
				var hd_checker = grid_user_absence.getEl().select('div.x-grid3-hd-checker');
				var hd = hd_checker.first();
				if (hd.hasClass('x-grid3-hd-checker-on')) {
					hd.removeClass('x-grid3-hd-checker-on');
				}
			}
		}
	});
	var createdTimestamp;
	var lastModified;
	var confirmedTimestamp;
	function longToDate(respText) {
		lastModified = formatTime(respText.anAbsence.lastModified, "", "");
		createdTimestamp = formatTime(respText.anAbsence.createdTimestamp, "",
				"");
		confirmedTimestamp = formatTime(respText.anAbsence.confirmedTimestamp,
				"", "");
	}
var cm_user_absence = new Ext.grid.ColumnModel(
	[sm_checkbox_selectAbsenceOfSomeone,
 	new Ext.grid.RowNumberer(),
 			{
			header : '用户名',
			width : 100,
			dataIndex : 'userName',
			sortable : true
		}, {
			header : '缺勤时间',
			width : 100,
			dataIndex : 'dateHalf',
			renderer : function(value, metadata, record) {
				return "<a href = 'javascript:void(0)' id = 'viewAbsence' name='view'"
						+ " onclick=javascript:viewAbsence('"
						+ record.data.absencerId
						+ "','"
						+ record.data.userName
						+ "','"
						+ record.data.dateHalf + "')>" + value + " </a>";
			},
			sortable : true
		}, {
			header : '缺勤类型',
			width : 80,
			dataIndex : 'type',
			sortable : true,
			renderer : function(value, metadata, record) {
				if (value == 1) {
					return '出差';
				} else {
					return '请假';
				};
			}
		}, {
			header : '出勤状态',
			width : 80,
			dataIndex : 'status',
			sortable : true,
			renderer : function(value, metadata, record) {
				if (value == 1) {
					return '缺勤';
				} else {
					return '出勤';
				};
			}
		}, {
			header : '确认状态',
			width : 80,
			dataIndex : 'confirmedStatus',
			sortable : true,
			renderer : function(value, metadata, record) {
				if (value == 0) {
					return '未确认';
				} else if (value == 1) {
					return '确认缺勤';
				} else {
					return '确认出勤';
				};
			}
		},  {
			header : '确认人',
			width : 100,
			hidden : true,
			dataIndex : 'confirmerName',
			renderer:function(value,record)
			{
				if(value==''){
					return '<font color="#CCCCCC">无</font>';
				}else{
					return value;
				}
			},
			sortable : true
		},  {
		    header : '确认时间', width : 120, dataIndex : 'confirmedTimestamp', hidden : true,
		    renderer: function(value,  record)
			{if(value==''){
				return '<font color="#CCCCCC">未确认</font>';
			}else{			
				return formatTime(value, null, record);
			}  },
		 sortable : true 
		},  {
			header : '最后修改人',
			width : 80,
			dataIndex : 'lastModifierName',
			sortable : true
		},  {
			header : '最后修改时间',
			width : 100,
			dataIndex : 'lastModified',
			renderer : function(value, metadata, record) {
				return formatTime(value, metadata, record);
			},
			sortable : true
		}, {
			header : "操作",
			width : 80,
			dataIndex : 'operation',
			renderer : function(value, metadata, record) {
			if((record.data.status == 1)&&(record.data.confirmedStatus==0)){
		    	return "<a href = 'javascript:void(0)' id = 'eliminateAbsence' name='eliminate' "
				+ "onclick=javascript:eliminateAbsence('"
				+ record.data.absencerId
				+ "','"
				+ record.data.userName
				+ "','"
				+ record.data.dateHalf + "')>销假 </a>&nbsp;&nbsp;&nbsp;";
		    } else{
			    	return " <font color='#CCCCCC'>销假</font>";
			    }
			}
}]);
/* ================查看缺勤信息详情 begin ======================== */
/** **********************查看缺勤信息详情窗口********************************* */

/************************************查看备注详情  begin ***********************************/
function showRemarkDetail(respText){
	return "<div align=\"center\"><a href='javascript:void(0)'  onclick=javascript:showRemarkOfSomeone('" + respText.anAbsence.userId
	 								+ "','"
									+respText.anAbsence.dateHalf+"')>备注详情</a></div>";
}
window.showRemarkOfSomeone = function(userId,dateHalf){
    Ext.Ajax.request({
        url: 'absence_viewTheAbsence_view.action',
        method: 'post',
        params: {
            absencerId : userId,
			dateHalf : dateHalf
        },
        success: function(resp, opts){
            var respText = Ext.util.JSON.decode(resp.responseText);
            if (respText.success) {
                var window_remark = new Ext.Window({
                    title: '备注详情',
                    closable: false,
                    width: 600,
                    resizable: false,
                    height: 400,
                    iconCls:"absence",
                    modal: true,
                    constrain: true,
                    closeAction: 'close',
                    layout: 'fit',
                    items: [{
                        xtype: 'htmleditor',
                        enableAlignments: false,
                        enableColors: false,
                        enableFont: false,
                        enableFontSize: false,
                        enableFormat: false,
                        enableLinks: false,
                        enableLists: false,
                        enableSourceEdit: false,
                        readOnly: true,
                        value: respText.anAbsence.remark
                    }],
                    buttons: [{
                        text: '关闭',
                        handler: function(){
                            window_remark.close();
                        }
                    }]
                
                
                }).show();
            }
        },
        failure: function(){
            Ext.Msg.show({
                title: '错误提示',
                msg: '查看失败!',
                buttons: Ext.Msg.OK,
                icon: Ext.Msg.ERROR,
                width: 200
            });
        }
    })
}
/************************************查看备注详情  end ***********************************/
viewAbsence=function(id,name, half) {
	Ext.Ajax.request({
		url : 'absence_viewTheAbsence_view.action',
		method : 'post',
		params : {
			absencerId : id,
			dateHalf : half,
			userName:name
		},
		success : function(resp, opts) {
			var respText = Ext.util.JSON.decode(resp.responseText);
			var type='';
			var status='';
			var confirmStatue='';
			if (respText.anAbsence.type == 1) {
				type= '出差';
			} else {
			    type= '请假';
		 	};
		 	if (respText.anAbsence.status == 1) {
			    status= '缺勤';
			} else {
				status= '出勤';
		    };
		    if(respText.anAbsence.confirmedStatus==0){
		    	confirmStatue='未确认';
		    }else if(respText.anAbsence.confirmedStatus==1){
		    	confirmStatue='确认缺勤';
		    }else {
		    	confirmStatue='确认出勤';
		    }
			if (respText.success) {
				longToDate(respText);
				var window_absence_view = new Ext.Window({
					title : '查看缺勤信息详情',
					width : 600,
					iconCls:'absence',
					resizable : false,
					closable:false,
					autoHeight : true,
					constrain: true,
					modal : true,
					closeAction : 'hide',
					items : [
					/** **********************查看缺勤信息详情表单********************************* */
					new Ext.FormPanel({
						border : false,
						baseCls : 'x-plain',
						bodyStyle : 'padding:5px 5px 0',
						autoWidth:true,
						labelAlign : 'right',
						labelWidth : 100,
						defaults : {
							itemCls : 'form_text unedit'
						},
						defaultType : 'textfield',
						items : [ {
									fieldLabel : '用户名  ',
									name : 'userName',
									readOnly : true,
									value :name,
									maxLength : 30
								}, {
									fieldLabel : '缺勤时间  ',
									name : 'dateHalf',
									readOnly : true,
									value : respText.anAbsence.dateHalf,
									maxLength : 30
								}, {
									name : 'type',
									fieldLabel : '缺勤类型 ',
									readOnly : true,
									value : type
								}, {
									name : 'status',
									readOnly : true,
									fieldLabel : '出勤状态  ',
									readOnly : true,
									value : status
								}, {
									name : 'confirmStatue',
									fieldLabel : '确认状态  ',
									readOnly : true,
									value : confirmStatue
								}, {
									fieldLabel : '创建时间  ',
									name : 'createdTimestamp',
									readOnly : true,
									//value : respText.anAbsence.createdTimestamp,
									value:formatTime(respText.anAbsence.createdTimestamp, "", ""),
									maxLength : 30
								}, {
									fieldLabel : '最后修改人',
									name : 'lastModifierName',
									readOnly : true,
									value : respText.anAbsence.lastModifierName,
									maxLength : 30
								}, {
									fieldLabel : '最后修改时间',
									name : 'lastModified',
									readOnly : true,
							    	//value:formatTime(respText.anAbsence.lastModified, "", "")
									value :lastModified
								}, {
									fieldLabel : '确认人',
									name : 'confirmerName',
									readOnly : true,
									value : respText.anAbsence.confirmerName,
									maxLength : 30
								}, {
									fieldLabel : '确认时间',
									name : 'confirmedTimestamp',
									readOnly:true,
									value : confirmedTimestamp,
									maxLength : 30
								},{
									xtype: 'panel',
									fieldLabel : '备注  ',// 实现时注意原记录不可以修改，只可以增加新的备注信息
		                            width: 425,
		                            itemCls: 'clear',
		                            html: showRemarkDetail(respText)
								}/*, {
									xtype : 'textfield',
									name : 'anAbsence.userId',
									value : respText.anAbsence.userId,
									hidden : true,
									maxLength : 30
								}*/],
						buttons : [{
									text : '关闭',
									type : 'button',
									handler : function() {
										window_absence_view.hide();
									}
								}]
					})
					/** **********************查看缺勤信息详情表单end********************************* */
					]
				});
				window_absence_view.show();
			} else {
				Ext.Msg.alert('查看详情失败');
			}
		},
		failure : function() {
			Ext.Msg.show({
						title : '错误提示',
						msg : '请求查看失败!',
						buttons : Ext.Msg.OK,
						icon : Ext.Msg.ERROR,
						width : 200
					});
		}
	});
};

/* ================查看缺勤记录详情 end ======================== */
			
/* ================取消缺勤记录 begin ======================== */
eliminateAbsence = function(id, name,half) {
	Ext.Ajax.request({
		url : 'absence_eliminateAbsenceByDateHalves_cancel.action',
		method : 'post',
		params : {
			abId:id,
			abDf:half
		},
		success : function(resp, opts) {
			var respText = Ext.util.JSON.decode(resp.responseText);
			if (respText.success){
			Ext.Msg.show({
					title : '销假成功',
					msg : respText.errorMessage,
					buttons : Ext.Msg.OK,
					icon : Ext.Msg.INFO,
					width : 200
			});
			ds_user_absence.load({
			  	 params:{
					 start:0,
					 limit:10
				 }
			});
			} else if(respText.success==false){
				Ext.Msg.show({
					title : '错误提示',
					msg : respText.errorMessage,
					buttons : Ext.Msg.OK,
					icon : Ext.Msg.ERROR,
					width : 200
				});
			}
		},
		failure : function() {
			 if (respText.failureType == 'server') {
				Ext.MessageBox.alert('错误', '操作失败 ');
			} else if (respText.failureType == 'connect') {
				Ext.Msg.alert('连接错误', '指定路径连接错误!');
			} else if (respText.failureType == 'client') {
				Ext.Msg.alert('提示', '数据错误，非法提交');
			} else {
				Ext.MessageBox.alert('警告', '服务器数据传输错误');
			}
		}
		});
};
/* ================取消缺勤记录 end ======================== */
/* ================添加缺勤记录 begin ======================== */

window_add_absence = new Ext.Window({
	title : '登记缺勤',
	width : 600,
	iconCls:'absence_add',
	resizable : false,
	autoHeight : true,
	closable:false,
	constrain: true,
	modal : true,
	closeAction : 'hide',
	items : [form_absence_add = new Ext.form.FormPanel({
		labelWidth : 70,
		labelAlign : 'right',
		url : 'absence_addAbsenceOfSomeone_add.action',
		border : false,
		baseCls : 'x-plain',
		bodyStyle : 'padding:5px 5px 0',
		autoWidth:true,
		defaults : {
			itemCls : 'form_text'
		},
		defaultType : 'textfield',
		items : [{
					xtype : 'combo',
					editable : false,
					store : new Ext.data.SimpleStore({
								data : [['1', '出差'], ['2', '请假']],
								fields : ['value', 'text']
							}),
					fieldLabel : '缺勤类型',
					name : 'absenceType',
					emptyText : '缺勤类型不能为空',
					allowBlank : false,
					mode : 'local',
					triggerAction : 'all',
					valueField : 'value',
					displayField : 'text'
				}, {
					xtype : 'datefield',
					name : 'startDate',
					emptyText : '日期类型为  年-月-日',
					fieldLabel : '开始日期',
					format : 'Y-m-d',// H:i:s
//					disabledDays : [0, 6],
					minValue:'2008-01-01',
					maxValue : '2020-12-31',
					allowBlank : false,
					increment : 30,
					maxLength : 70
				}, {
					xtype : 'datefield',
					name : 'endDate',
					emptyText : '日期类型为  年-月-日',
					fieldLabel : '结束日期',
					format : 'Y-m-d',
//					disabledDays : [0, 6],
					minValue:'2008-01-01',
					maxValue : '2020-12-31',
					allowBlank : false
				}, {
					xtype : 'timefield',
					name : 'startHour',
					editable : false,
					emptyText : '请选择',
					fieldLabel : '开始时间',
					minValue : '08:00 AM',
					maxValue : '18:00 PM',
					increment : 30
				}, {
					xtype : 'timefield',
					editable : false,
					name : 'endHour',
					emptyText : '请选择',
					fieldLabel : '结束时间',
					minValue : '08:00 AM',
					maxValue : '18:00 PM',
					increment : 30
				}, {
					xtype : 'textarea',
					itemCls : 'form_long clear',
					width : 440,
					fieldLabel : '缺勤备注',
					height : 80,
					name : 'remark',
					maxLength : 200
				}],
		buttonAlign : 'right',
		minButtonWidth : 60,
		buttons : [{
			text : '登记',
			handler : function() {
				if (!form_absence_add.getForm().isValid())
					return;
				form_absence_add.getForm().submit({
							success : function(form, action) {
								if (action.result.success) {
									Ext.Msg.show({
												title : '登记成功',
												msg : action.result.errorMessage,
												buttons : Ext.Msg.OK,
												icon : Ext.Msg.INFO,
												width : 200
											});
									ds_user_absence.load({
												params : {
													start : 0,
													limit : 10
												}
											});
									window_add_absence.hide();
								}
							},
							// 提交失败的回调函数
							failure : function(form, action) {
								if (action.result.success == false) {
									Ext.Msg.show({
												title : '错误提示',
												msg : action.result.errorMessage,
												buttons : Ext.Msg.OK,
												icon : Ext.Msg.ERROR,
												width : 200,
												fn:function(){
													window_add_absence.show();
												}
											});
								} else if (action.failureType == 'server') {
									Ext.MessageBox.alert('错误', '操作失败 ');
								} else if (action.failureType == 'connect') {
									Ext.Msg.alert('连接错误', '指定路径连接错误!');
								} else if (action.failureType == 'client') {
									Ext.Msg.alert('提示', '数据错误，非法提交');
								} else {
									Ext.MessageBox.alert('警告', '服务器数据传输错误');
								}
							}
						}),
						window_add_absence.hide();
			}
		}, {
			text : '重置',
			handler : function() {
				form_absence_add.getForm().reset();
			}
		}, {
			text : '取消',
			type : 'button',
			handler : function() {
				window_add_absence.hide();
			}

		}]
	})]

});

	/* ================添加缺勤记录 end ======================== */
	/* ================取消缺勤记录 begin ======================== */

	window_eliminate_absence = new Ext.Window({
		title : '取消缺勤登记',
		width : 600,
		iconCls:'absence_del',
		resizable : false,
		closable:false,
		autoHeight : true,
		modal : true,
		closeAction : 'hide',
		items : [form_absence_eliminate = new Ext.form.FormPanel({
			labelWidth : 70,
			labelAlign : 'right',
			url : 'absence_eliminateAbsence_cancel.action',
			border : false,
			baseCls : 'x-plain',
			bodyStyle : 'padding:5px 5px 0',
			autoWidth:true,
			defaults : {
				itemCls : 'form_text',
				msgTarget : 'qtip'
			},
			defaultType : 'textfield',
			items : [
					   {
						xtype : 'datefield',
						name : 'startDate',
						emptyText : '日期类型为  年-月-日',
						fieldLabel : '开始日期',
						format : 'Y-m-d',// H:i:s
//						disabledDays : [0, 6],
						allowBlank : false,
						minValue:'2008-01-01',
						maxValue : '2020-12-31',
						increment : 30,
						maxLength : 70
					}, {
						xtype : 'timefield',
						name : 'startHour',
						emptyText : '请选择',
						fieldLabel : '开始时间',
						minValue : '08:00 AM',
						maxValue : '18:00 PM',
						increment : 30
					}, {
						xtype : 'datefield',
						name : 'endDate',
						emptyText : '日期类型为  年-月-日',
						fieldLabel : '结束日期',
						format : 'Y-m-d',
//						disabledDays : [0, 6],
						minValue:'2008-01-01',
						maxValue : '2020-12-31',
						allowBlank : false
					}, {
						xtype : 'timefield',
						name : 'endHour',
						emptyText : '请选择',
						fieldLabel : '结束时间',
						minValue : '08:00 AM',
						maxValue : '18:00 PM',
						increment : 30
					}, {
						xtype : 'textfield',
						name : 'absentName',
						hidden : true
					}],
			buttonAlign : 'right',
			minButtonWidth : 60,
			buttons : [{
				text : '取消登记',
				handler : function() {
					if (!form_absence_eliminate.getForm().isValid())
						return;
					form_absence_eliminate.getForm().submit({
								success : function(form, action) {
									if (action.result.success) {
										Ext.Msg.show({
													title : '取消成功',
													msg : action.result.errorMessage,
													buttons : Ext.Msg.OK,
													icon : Ext.Msg.INFO,
													width : 200
												});
												ds_user_absence.load({
													params : {
														start : 0,
														limit : 10
													}
												});
										window_eliminate_absence.hide();
									}
								},
								// 提交失败的回调函数
								failure : function(form, action) {
									if (action.result.success == false) {
										Ext.Msg.show({
													title : '错误提示',
													msg : action.result.errorMessage,
													buttons : Ext.Msg.OK,
													icon : Ext.Msg.ERROR,
													width : 200,
													fn:function(){
														window_eliminate_absence.show();
													}
												});
									} else if (action.failureType == 'server') {
										Ext.MessageBox.alert('错误', '操作失败 ');
									} else if (action.failureType == 'connect') {
										Ext.Msg.alert('连接错误', '指定路径连接错误!');
									} else if (action.failureType == 'client') {
										Ext.Msg.alert('提示', '数据错误，非法提交');
									} else {
										Ext.MessageBox.alert('警告', '服务器数据传输错误');
									}
								}
							}), window_eliminate_absence.hide();
				}
			}, {
				text : '重置',
				handler : function() {
					form_absence_eliminate.getForm().reset();
				}
			}, {
				text : '取消',
				type : 'button',
				handler : function() {
					window_eliminate_absence.hide();
				}

			}]
		})]

	});
    /* ================取消缺勤记录 end ======================== */
	/* ================精确查询缺勤记录 begin ======================== */

var form_absence_exactSearch = new Ext.form.FormPanel({
			labelWidth :80,
			labelAlign : 'right',
			url : 'absence_absencesOfUser_list.action',
			border : false,
			baseCls : 'x-plain',
			bodyStyle : 'padding:5px 5px 0',
			autoWidth:true,
			defaults : {
			itemCls : 'form_text',
			msgTarget : 'qtip'
			},
			defaultType : 'textfield',
			items : [
						{
						xtype : 'combo',
						editable : false,
						store : new Ext.data.SimpleStore({
									data : [['1', '出差'], ['2', '请假']],
									fields : ['value', 'text']
								}),
						fieldLabel : '缺勤类型',
						name : 'absenceType',
						emptyText : '请选择',
						type : 'short',
						mode : 'local',
						triggerAction : 'all',
						valueField : 'value',
						displayField : 'text'
					},  {
						xtype : 'combo',
						editable : false,
						name : 'isConfirmed',
						store : new Ext.data.SimpleStore({
									data : [['1', '未确认'], 
											['2', '已确认']],
									fields : ['value', 'text']
								}),
						fieldLabel : '确认状态  ',
						emptyText : '请选择',
						mode : 'local',
						triggerAction : 'all',
						displayField : 'text',
						valueField : 'value',
						maxLength : 30
					}, {
						xtype : 'datefield',
						name : 'startDate',
						// emptyText : '日期类型为 年-月-日',
						fieldLabel : '开始日期',
						format : 'Y-m-d',// H:i:s
//						disabledDays : [0, 6],
						minValue:'2008-01-01',
						maxValue : '2020-12-31',
						increment : 30,
						maxLength : 70
					}, {
						xtype : 'datefield',
						name : 'endDate',
						// emptyText : '日期类型为 年-月-日',
						fieldLabel : '结束日期',
						minValue:'2008-01-01',
						maxValue : '2020-12-31',
						format : 'Y-m-d'
//						disabledDays : [0, 6]
					}, {
						xtype : 'timefield',
						name : 'startHour',
						// emptyText : '请选择',
						fieldLabel : '开始时间',
						minValue : '08:00 AM',
						maxValue : '18:00 PM',
						increment : 30
					},  {
						xtype : 'timefield',
						name : 'endHour',
						// emptyText : '请选择',
						fieldLabel : '结束时间',
						minValue : '08:00 AM',
						maxValue : '18:00 PM',
						increment : 30
					}],
			buttonAlign : 'right',
			minButtonWidth : 60,
			buttons : [{
				text : '查询',
				type : 'submit',
				handler : function() {
				if (!form_absence_exactSearch.getForm().isValid())
					return;
					form_absence_exactSearch.getForm().submit({
						method : 'post',
						params : '',
						success : function(form, action) {
							if (action.result.success) {
								Ext.Msg.show({
									title : '查询成功',
									msg : action.result.errorMessage,
									buttons : Ext.Msg.OK,
									icon : Ext.Msg.INFO,
									width : 200
								});
								//Ext.MessageBox.alert('恭喜', '查询成功 ');
								ds_user_absence.baseParams =
									  form_absence_exactSearch.getForm().getValues();
							    ds_user_absence.load({ params : { start : 0, limit : 10 }	 });
							} else {
								Ext.Msg.show({
											title : '错误提示',
											msg : action.result.errorMessage,
											buttons : Ext.Msg.OK,
											icon : Ext.Msg.ERROR,
											width : 200
										});
							}
						},
						failure : function(form, action) {
							if (action.result.success==false){
								Ext.Msg.show({
									title : '操作提示',
									msg : action.result.errorMessage,
									buttons : Ext.Msg.OK,
									icon : Ext.Msg.ERROR,
									width : 200,
									fn:function(){
										window_absence_exactSearch.show();
									}
								});
							}else if (action.failureType == 'server') {
								Ext.MessageBox.alert('错误', '操作失败 ');
							} else if (action.failureType == 'connect') {
								Ext.Msg.alert('连接错误', '指定路径连接错误!');
							} else if (action.failureType == 'client') {
								Ext.Msg.alert('提示', '数据错误，非法提交');
							} else {
								Ext.MessageBox.alert('警告', '服务器数据传输错误');
							}
						}
							 
						});
					window_absence_exactSearch.hide();
				}
				}, {
				text : '重置',
				handler : function() {
					form_absence_exactSearch.getForm().reset();
				}
			}, {
				text : '取消',
				type : 'button',
				handler : function() {
					window_absence_exactSearch.hide();
				}

			}]
		});
var window_absence_exactSearch = new Ext.Window({
			title : '查询缺勤记录',
			width : 600,
			iconCls:'absence_search',
			resizable : false,
			closable:false,
			autoHeight : true,
			modal : true,
			closeAction : 'hide',
			items : form_absence_exactSearch

		});

/* ================精确查询缺勤记录 end ======================== */
	var btn_add_absence = new Ext.Button({
				text : '登记缺勤',
				region : 'left',
				iconCls:'absence_add',
				style : '宋体',
				handler : function() {
					form_absence_add.getForm().reset();
					window_add_absence.show();
				}
			});
	var btn_eliminate_absence = new Ext.Button({
				text : '取消缺勤登记',
				iconCls:'absence_del',
				region : 'left',
				style : '宋体',
				handler : function() {
					form_absence_eliminate.getForm().reset();
					window_eliminate_absence.show();
				}
			});
	var btn_search_absence = new Ext.Button({
				text : '查询缺勤记录',
				region : 'left',
				iconCls:'absence_search',
				style : '宋体',
				handler : function() {
					 form_absence_exactSearch.getForm().reset();
					 window_absence_exactSearch.show();
				}
			});
	var btn_eliminateOnList_absence=new Ext.Button({
	text : '取消选中缺勤登记',
	iconCls:'absence_del',
	region : 'left',
	style : '宋体',
	handler:function(){
		selections=grid_user_absence.getSelectionModel().getSelections();
	    if(selections.length==0||selections.length < 0){
	    	Ext.Msg.show({
					title : '信息提示',
					msg : '请选中要取消的记录',
					buttons : Ext.Msg.OK,
					icon : Ext.Msg.INFO,
					width : 200
				});
			return;
		}else if(selections.length>0){
			var flag=0;
			for(var i=0;i<selections.length;i++){
				//alert(selections[i].get("status"));
				if((selections[i].get("status")==1)&&(selections[i].get("confirmedStatus")==0)){
					flag++;
				}
			}
			if(flag>0){
				for(var i=0;i<selections.length;i++){
					   abId[i]=selections[i].get("absencerId"); 
						abDf[i]=selections[i].get("dateHalf");
					}
					Ext.Ajax.request({
						url:'absence_eliminateAbsenceByDateHalves_cancel.action',
						method:'post',
						params:{
							abId:abId,
						    abDf:abDf
						},
						success : function(resp, opts) {
							var respText = Ext.util.JSON.decode(resp.responseText);
							if (respText.success){
							Ext.Msg.show({
									title : '取消成功',
									msg : respText.errorMessage,
									buttons : Ext.Msg.OK,
									icon : Ext.Msg.INFO,
									width : 200
								});
							ds_user_absence.load({
								params : {
									start : 0,
									limit : 10,
									absenceType : '',
									isConfirmed:'',
									startDate:''
								}
							});
							} else if(respText.success==false){
								Ext.Msg.show({
									title : '错误提示',
									msg : respText.errorMessage,
									buttons : Ext.Msg.OK,
									icon : Ext.Msg.ERROR,
									width : 200
								});
							}
						   },
							failure : function() {
								 if (respText.failureType == 'server') {
									Ext.MessageBox.alert('错误', '操作失败 ');
								} else if (respText.failureType == 'connect') {
									Ext.Msg.alert('连接错误', '指定路径连接错误!');
								} else if (respText.failureType == 'client') {
									Ext.Msg.alert('提示', '数据错误，非法提交');
								} else {
									Ext.MessageBox.alert('警告', '服务器数据传输错误');
								}
							}
					});
			}else{
				Ext.Msg.show({
					title : '错误提示',
					msg : '无需再次取消',
					buttons : Ext.Msg.OK,
					icon : Ext.Msg.ERROR,
					width : 200
				});
			}
		}else{
			return;
		}
	}
});

var btn_allAbsence_absence = new Ext.Button({
	text : '列出所有缺勤',
	iconCls:'refresh',
	region : 'left',
	style : '宋体',
	handler : function() {
		ds_user_absence.baseParams = null;
		ds_user_absence.load({
			params : {
				start : 0,
				limit : 10,
				absenceType : '',
				isConfirmed:'',
				startDate:''
			}
		});
	}
});
	var grid_user_absence = new Ext.grid.GridPanel({
				title : '',
//				autoWidth : true,
				width :786,
				height:400,
//				autoHeight : true,
				loadMask : {
					errorMessage : '数据加载中...'
				},
				cm : cm_user_absence,
				sm:sm_checkbox_selectAbsenceOfSomeone,
				ds : ds_user_absence,
				store : ds_user_absence,
				region : 'center',
				tbar : [btn_search_absence,btn_add_absence, btn_eliminate_absence,btn_eliminateOnList_absence,
						 btn_allAbsence_absence],
				bbar : new Ext.PagingToolbar({
							pageSize : 10,
							store : ds_user_absence,
							displayInfo : true,
							beforePageText : '第',
							afterPageText : '页-共{0}页',
							displayMsg : '显示{0} - {1} 条  共 {2} 条',
							emptyMsg : "没有记录"
						})
			});
var abId=new Array();
var abDf=new Array();
var selections=grid_user_absence.getSelectionModel().getSelections();
/*grid_user_absence.on('click',function(){
	var selections=grid_user_absence.getSelectionModel().getSelections();
		for(var i=0;i<selections.length;i++){
			abId[i]=selections[i].get("absencerId");
			abDf[i]=selections[i].get("dateHalf");
		}
});*/
ds_user_absence.on('datachanged',autoCheckGridHead);
ds_user_absence.on('load',dde);
function dde(){
	sm_checkbox_selectAbsenceOfSomeone.clearSelections();
}
function autoCheckGridHead(){
	var hd_checker = grid_user_absence.getEl().select('div.x-grid3-hd-checker');  
    var hd = hd_checker.first(); 
    if(hd != null){ 
    	if(selections.length != grid_user_absence.getStore().getCount()){ 
                //清空表格头的checkBox  
        	if(hd.hasClass('x-grid3-hd-checker-on')){
            	hd.removeClass('x-grid3-hd-checker-on');    
			    //x-grid3-hd-checker-on
                //grid_taskQueryPop.getSelectionModel().clearSelections();
             }
         }else{
             if(grid_user_absence.getStore().getCount() == 0){ //没有记录的话清空;
              return;
             }
             hd.addClass('x-grid3-hd-checker-on');
                grid_user_absence.getSelectionModel().selectAll();
            }
        }
 }
ds_user_absence.load({
	params : {
		start : 0,
		limit : 10
	}
});
	var window_my_absence = new Ext.Window({
				title : '个人缺勤管理',
				 width :800,
//				autoWidth : true,
				resizable : false,
				autoHeight : true,
				closable:false,
				// height:'800',
				modal : true,
				closeAction : 'close',
				// minimizable:true,//允许最小化
				// maximizable:true,//允许最大化
				constrain: true,
				buttonAlign : 'right',
				minButtonWidth : 60,
				items : [grid_user_absence],
		         buttons :[{
					text : '关闭',
					type : 'button',
					handler : function() {
						window_my_absence.hide();
					}
				}]
			});
	window_my_absence.show();
}